});
box.add(expander);
- let errortext = `${exc}\n\nStack trace:\n${
- // Indent stack trace.
- exc.stack.split('\n').map(line => ` ${line}`).join('\n')
- }`;
+ let errortext = '%s\n\nStack trace:\n'.format(exc);
+ // Indent stack trace.
+ errortext +=
+ exc.stack.split('\n').map(line => ' %s'.format(line)).join('\n');
let buffer = new Gtk.TextBuffer({ text: errortext });
let textview = new Gtk.TextView({
let clipboard = Gtk.Clipboard.get_default(w.get_display());
// markdown for pasting in gitlab issues
let lines = [
- `The settings of extension ${row.uuid} had an error:`,
+ 'The settings of extension %s had an error:'.format(row.uuid),
'```', // '`' (xgettext throws up on odd number of backticks)
- `${exc}`,
+ exc.toString(),
'```', // '`'
'',
'Stack trace:',
this._shellProxy.ListExtensionsRemote(([extensionsMap], e) => {
if (e) {
if (e instanceof Gio.DBusError) {
- log(`Failed to connect to shell proxy: ${e}`);
+ log('Failed to connect to shell proxy: %s'.format(e.toString()));
this._mainStack.visible_child_name = 'noshell';
} else {
throw e;
this._updatesIcon.visible = this.hasUpdate;
- this._versionLabel.label = `${this.version}`;
+ this._versionLabel.label = this.version;
this._versionLabel.visible = this.version !== '';
- this._authorLabel.label = `${this.creator}`;
+ this._authorLabel.label = this.creator;
this._authorLabel.visible = this.creator !== '';
}
},
logError(s) {
- log(`ERROR: ${s}`);
+ log('ERROR: %s'.format(s));
},
userdatadir: GLib.build_filenamev([GLib.get_user_data_dir(), 'gnome-shell']),
this._settings = new Gio.Settings({ schema_id: GdmUtil.LOGIN_SCREEN_SCHEMA });
- this._settings.connect(`changed::${GdmUtil.BANNER_MESSAGE_KEY}`,
+ this._settings.connect('changed::%s'.format(GdmUtil.BANNER_MESSAGE_KEY),
this._updateBanner.bind(this));
- this._settings.connect(`changed::${GdmUtil.BANNER_MESSAGE_TEXT_KEY}`,
+ this._settings.connect('changed::%s'.format(GdmUtil.BANNER_MESSAGE_TEXT_KEY),
this._updateBanner.bind(this));
- this._settings.connect(`changed::${GdmUtil.DISABLE_USER_LIST_KEY}`,
+ this._settings.connect('changed::%s'.format(GdmUtil.DISABLE_USER_LIST_KEY),
this._updateDisableUserList.bind(this));
- this._settings.connect(`changed::${GdmUtil.LOGO_KEY}`,
+ this._settings.connect('changed::%s'.format(GdmUtil.LOGO_KEY),
this._updateLogo.bind(this));
this._textureCache = St.TextureCache.get_default();
this._userManager.connect('user-removed',
() => this._updateMultiUser());
- this._lockdownSettings.connect(`changed::${DISABLE_USER_SWITCH_KEY}`,
+ this._lockdownSettings.connect('changed::%s'.format(DISABLE_USER_SWITCH_KEY),
() => this._updateSwitchUser());
- this._lockdownSettings.connect(`changed::${DISABLE_LOG_OUT_KEY}`,
+ this._lockdownSettings.connect('changed::%s'.format(DISABLE_LOG_OUT_KEY),
() => this._updateLogout());
- global.settings.connect(`changed::${ALWAYS_SHOW_LOG_OUT_KEY}`,
+ global.settings.connect('changed::%s'.format(ALWAYS_SHOW_LOG_OUT_KEY),
() => this._updateLogout());
- this._lockdownSettings.connect(`changed::${DISABLE_LOCK_SCREEN_KEY}`,
+ this._lockdownSettings.connect('changed::%s'.format(DISABLE_LOCK_SCREEN_KEY),
() => this._updateLockScreen());
- this._lockdownSettings.connect(`changed::${DISABLE_LOG_OUT_KEY}`,
+ this._lockdownSettings.connect('changed::%s'.format(DISABLE_LOG_OUT_KEY),
() => this._updateHaveShutdown());
this.forceUpdate();
const _notTrailingJunk = '[^\\s`!()\\[\\]{};:\'\\".,<>?\u00AB\u00BB\u200E\u200F\u201C\u201D\u2018\u2019\u202A\u202C]';
const _urlRegexp = new RegExp(
- `(^|${_leadingJunk})` +
+ '(^|%s)'.format(_leadingJunk) +
'(' +
'(?:' +
'(?:http|https|ftp)://' + // scheme://
'(?:' + // one or more:
'[^\\s()<>]+' + // run of non-space non-()
'|' + // or
- `${_balancedParens}` + // balanced parens
+ '%s'.format(_balancedParens) + // balanced parens
')+' +
'(?:' + // end with:
- `${_balancedParens}` + // balanced parens
+ '%s'.format(_balancedParens) + // balanced parens
'|' + // or
- `${_notTrailingJunk}` + // last non-junk char
+ '%s'.format(_notTrailingJunk) + // last non-junk char
')' +
')', 'gi');
} catch (err) {
// Replace "Error invoking GLib.shell_parse_argv: " with
// something nicer
- err.message = err.message.replace(/[^:]*: /, `${_("Could not parse command:")}\n`);
+ err.message = err.message.replace(/[^:]*: /, '%s\n'.format(_('Could not parse command:')));
throw err;
}
};
const CONNECTIVITY_CHECK_HOST = 'nmcheck.gnome.org';
-const CONNECTIVITY_CHECK_URI = `http://${CONNECTIVITY_CHECK_HOST}`;
const CONNECTIVITY_RECHECK_RATELIMIT_TIMEOUT = 30 * GLib.USEC_PER_SEC;
const HelperDBusInterface = loadInterfaceXML('org.gnome.Shell.PortalHelper');
this._headerBar.show();
if (!url) {
- url = CONNECTIVITY_CHECK_URI;
+ url = 'http://%s'.format(CONNECTIVITY_CHECK_HOST);
this._originalUrlWasGnome = true;
} else {
this._originalUrlWasGnome = false;
let [handle, appId, parentWindow_, title, description, body, options] = params;
// We probably want to use parentWindow and global.display.focus_window
// for this check in the future
- if (appId && `${appId}.desktop` != this._windowTracker.focus_app.id) {
+ if (appId && '%s.desktop'.format(appId) != this._windowTracker.focus_app.id) {
invocation.return_error_literal(Gio.DBusError,
Gio.DBusError.ACCESS_DENIED,
'Only the focused app is allowed to show a system access dialog');
if (folder.get_boolean('translate')) {
let keyfile = new GLib.KeyFile();
- let path = `desktop-directories/${name}`;
+ let path = 'desktop-directories/%s'.format(name);
try {
keyfile.load_from_data_dirs(path, GLib.KeyFileFlags.NONE);
if (this._items.has(id))
this._items.get(id).navigate_focus(null, St.DirectionType.TAB_FORWARD, false);
else
- log(`No such application ${id}`);
+ log('No such application %s'.format(id));
}
selectApp(id) {
}
adaptToSize(_width, _height) {
- throw new GObject.NotImplementedError(`adaptToSize in ${this.constructor.name}`);
+ throw new GObject.NotImplementedError('adaptToSize in %s'.format(this.constructor.name));
}
});
let folders = this._folderSettings.get_strv('folder-children');
folders.forEach(id => {
- let path = `${this._folderSettings.path}folders/${id}/`;
+ let path = '%sfolders/%s/'.format(this._folderSettings.path, id);
let icon = this._items.get(id);
if (!icon) {
icon = new FolderIcon(id, path, this);
shellWorkspaceLaunch(params) {
let { stack } = new Error();
- log(`shellWorkspaceLaunch is deprecated, use app.open_new_window() instead\n${stack}`);
+ log('shellWorkspaceLaunch is deprecated, use app.open_new_window() instead\n%s'.format(stack));
params = Params.parse(params, { workspace: -1,
timestamp: 0 });
constructor() {
this.FAVORITE_APPS_KEY = 'favorite-apps';
this._favorites = {};
- global.settings.connect(`changed::${this.FAVORITE_APPS_KEY}`, this._onFavsChanged.bind(this));
+ global.settings.connect('changed::%s'.format(this.FAVORITE_APPS_KEY), this._onFavsChanged.bind(this));
this.reload();
}
let app = Shell.AppSystem.get_default().lookup_app(desktopFile);
if (!app) {
- log(`Settings panel for desktop file ${desktopFile} could not be loaded!`);
+ log('Settings panel for desktop file %s could not be loaded!'.format(desktopFile));
return;
}
var MESSAGE_ICON_SIZE = -1; // pick up from CSS
-var NC_ = (context, str) => `${context}\u0004${str}`;
+var NC_ = (context, str) => '%s\u0004%s'.format(context, str);
function sameYear(dateA, dateB) {
return dateA.getYear() == dateB.getYear();
Signals: { 'changed': {} },
}, class EventSourceBase extends GObject.Object {
get isLoading() {
- throw new GObject.NotImplementedError(`isLoading in ${this.constructor.name}`);
+ throw new GObject.NotImplementedError('isLoading in %s'.format(this.constructor.name));
}
get hasCalendars() {
- throw new GObject.NotImplementedError(`hasCalendars in ${this.constructor.name}`);
+ throw new GObject.NotImplementedError('hasCalendars in %s'.format(this.constructor.name));
}
destroy() {
}
requestRange(_begin, _end) {
- throw new GObject.NotImplementedError(`requestRange in ${this.constructor.name}`);
+ throw new GObject.NotImplementedError('requestRange in %s'.format(this.constructor.name));
}
getEvents(_begin, _end) {
- throw new GObject.NotImplementedError(`getEvents in ${this.constructor.name}`);
+ throw new GObject.NotImplementedError('getEvents in %s'.format(this.constructor.name));
}
hasEvents(_day) {
- throw new GObject.NotImplementedError(`hasEvents in ${this.constructor.name}`);
+ throw new GObject.NotImplementedError('hasEvents in %s'.format(this.constructor.name));
}
});
// about the HasCalendars property and would cause an exception trying
// to read it)
} else {
- log(`Error loading calendars: ${e.message}`);
+ log('Error loading calendars: %s'.format(e.message));
return;
}
}
this._weekStart = Shell.util_get_week_start();
this._settings = new Gio.Settings({ schema_id: 'org.gnome.desktop.calendar' });
- this._settings.connect(`changed::${SHOW_WEEKDATE_KEY}`, this._onSettingsChange.bind(this));
+ this._settings.connect('changed::%s'.format(SHOW_WEEKDATE_KEY), this._onSettingsChange.bind(this));
this._useWeekdate = this._settings.get_boolean(SHOW_WEEKDATE_KEY);
/**
// Hack used in lieu of border-collapse - see gnome-shell.css
if (row == 2)
- styleClass = `calendar-day-top ${styleClass}`;
+ styleClass = 'calendar-day-top %s'.format(styleClass);
let leftMost = rtl
? iter.getDay() == (this._weekStart + 6) % 7
: iter.getDay() == this._weekStart;
if (leftMost)
- styleClass = `calendar-day-left ${styleClass}`;
+ styleClass = 'calendar-day-left %s'.format(styleClass);
if (sameDay(now, iter))
styleClass += ' calendar-today';
let rtl = Clutter.get_default_text_direction() == Clutter.TextDirection.RTL;
if (this._event.date < periodBegin && !this._event.allDay) {
if (rtl)
- title = `${title}${ELLIPSIS_CHAR}`;
+ title = '%s%s'.format(title, ELLIPSIS_CHAR);
else
- title = `${ELLIPSIS_CHAR}${title}`;
+ title = '%s%s'.format(ELLIPSIS_CHAR, title);
}
if (this._event.end > periodEnd && !this._event.allDay) {
if (rtl)
- title = `${ELLIPSIS_CHAR}${title}`;
+ title = '%s%s'.format(ELLIPSIS_CHAR, title);
else
- title = `${title}${ELLIPSIS_CHAR}`;
+ title = '%s%s'.format(title, ELLIPSIS_CHAR);
}
return title;
}
for (let prop of ['visible', 'empty', 'can-clear']) {
connectionsIds.push(
- section.connect(`notify::${prop}`, this._sync.bind(this)));
+ section.connect('notify::%s'.format(prop), this._sync.bind(this)));
}
connectionsIds.push(section.connect('message-focused', (_s, messageActor) => {
Util.ensureActorVisibleInScrollView(this._scrollView, messageActor);
try {
drive.stop_finish(res);
} catch (e) {
- log(`Unable to stop the drive after drive-eject-button ${e.toString()}`);
+ log('Unable to stop the drive after drive-eject-button %s'.format(e.toString()));
}
});
} else if (drive.can_eject()) {
try {
drive.eject_with_operation_finish(res);
} catch (e) {
- log(`Unable to eject the drive after drive-eject-button ${e.toString()}`);
+ log('Unable to eject the drive after drive-eject-button %s'.format(e.toString()));
}
});
}
}
if (!e.matches(Gio.IOErrorEnum, Gio.IOErrorEnum.FAILED_HANDLED))
- log(`Unable to mount volume ${volume.get_name()}: ${e.toString()}`);
+ log('Unable to mount volume %s: %s'.format(volume.get_name(), e.toString()));
this._closeOperation(volume);
}
}
retval = app.launch(files,
global.create_app_launch_context(0, -1));
} catch (e) {
- log(`Unable to launch the application ${app.get_name()}: ${e}`);
+ log('Unable to launch the application %s: %s'.format(app.get_name(), e.toString()));
}
return retval;
try {
contentTypes = mount.guess_content_type_finish(res);
} catch (e) {
- log(`Unable to guess content types on added mount ${mount.get_name()}: ${e}`);
+ log('Unable to guess content types on added mount %s: %s'.format(mount.get_name(), e.toString()));
}
if (contentTypes.length) {
validate: this._validateWpaPsk, password: true });
break;
case 'none': // static WEP
- secrets.push({ label: _('Key'), key: `wep-key${wirelessSecuritySetting.wep_tx_keyidx}`,
- value: wirelessSecuritySetting.get_wep_key(wirelessSecuritySetting.wep_tx_keyidx) || '',
- wep_key_type: wirelessSecuritySetting.wep_key_type,
- validate: this._validateStaticWep, password: true });
+ secrets.push({
+ label: _('Key'),
+ key: 'wep-key%s'.format(wirelessSecuritySetting.wep_tx_keyidx),
+ value: wirelessSecuritySetting.get_wep_key(wirelessSecuritySetting.wep_tx_keyidx) || '',
+ wep_key_type: wirelessSecuritySetting.wep_key_type,
+ validate: this._validateStaticWep,
+ password: true,
+ });
break;
case 'ieee8021x':
if (wirelessSecuritySetting.auth_alg == 'leap') { // Cisco LEAP
this._get8021xSecrets(secrets);
break;
default:
- log(`Invalid wireless key management: ${wirelessSecuritySetting.key_mgmt}`);
+ log('Invalid wireless key management: %s'.format(wirelessSecuritySetting.key_mgmt));
}
}
value: ieee8021xSetting.private_key_password || '', password: true });
break;
default:
- log(`Invalid EAP/IEEE802.1x method: ${ieee8021xSetting.get_eap_method(0)}`);
+ log('Invalid EAP/IEEE802.1x method: %s'.format(ieee8021xSetting.get_eap_method(0)));
}
}
this._getMobileSecrets(content.secrets, connectionType);
break;
default:
- log(`Invalid connection type: ${connectionType}`);
+ log('Invalid connection type: %s'.format(connectionType));
}
return content;
try {
vpnSetting.foreach_data_item((key, value) => {
- this._stdin.write(`DATA_KEY=${key}\n`, null);
- this._stdin.write(`DATA_VAL=${value || ''}\n\n`, null);
+ this._stdin.write('DATA_KEY=%s\n'.format(key), null);
+ this._stdin.write('DATA_VAL=%s\n\n'.format(value || ''), null);
});
vpnSetting.foreach_secret((key, value) => {
- this._stdin.write(`SECRET_KEY=${key}\n`, null);
- this._stdin.write(`SECRET_VAL=${value || ''}\n\n`, null);
+ this._stdin.write('SECRET_KEY=%s\n'.format(key), null);
+ this._stdin.write('SECRET_VAL=%s\n\n'.format(value || ''), null);
});
this._stdin.write('DONE\n\n', null);
} catch (e) {
let monitor = this._pluginDir.monitor(Gio.FileMonitorFlags.NONE, null);
monitor.connect('changed', () => (this._vpnCacheBuilt = false));
} catch (e) {
- log(`Failed to create monitor for VPN plugin dir: ${e.message}`);
+ log('Failed to create monitor for VPN plugin dir: %s'.format(e.message));
}
this._native.connect('new-request', this._newRequest.bind(this));
body = _("A password is required to connect to “%s”.").format(connectionSetting.get_id());
break;
default:
- log(`Invalid connection type: ${connectionType}`);
+ log('Invalid connection type: %s'.format(connectionType));
this._native.respond(requestId, Shell.NetworkAgentResponse.INTERNAL_ERROR);
return;
}
let bodyContent = new Dialog.MessageDialogContent();
if (userNames.length > 1) {
- log(`polkitAuthenticationAgent: Received ${userNames.length} ` +
+ log('polkitAuthenticationAgent: Received %d'.format(userNames.length) +
'identities that can be used for authentication. Only ' +
'considering one.');
}
// We could add retrying if this turns out to be a problem
log('polkitAuthenticationAgent: Failed to show modal dialog. ' +
- `Dismissing authentication request for action-id ${this.actionId} ` +
- `cookie ${this._cookie}`);
+ 'Dismissing authentication request for action-id %s '.format(this.actionId) +
+ 'cookie %s'.format(this._cookie));
this._emitDone(true);
}
}
try {
this._client.register();
} catch (e) {
- throw new Error(`Could not register Telepathy client. Error: ${e}`);
+ throw new Error('Could not register Telepathy client. Error: %s'.format(e.toString()));
}
if (!this._client.account_manager.is_prepared(Tp.AccountManager.get_feature_quark_core()))
dispatchOp.claim_with_finish(result);
this._handlingChannels(account, conn, [channel], false);
} catch (err) {
- log(`Failed to Claim channel: ${err}`);
+ log('Failed to Claim channel: %s'.format(err.toString()));
}
});
_onProxyReady(proxy, error) {
if (error) {
- log(`Failed to create GNOME Clocks proxy: ${error}`);
+ log('Failed to create GNOME Clocks proxy: %s'.format(error));
return;
}
try {
this._updatesPermission = Polkit.Permission.new_finish(res);
} catch (e) {
- log(`No permission to trigger offline updates: ${e}`);
+ log('No permission to trigger offline updates: %s'.format(e.toString()));
}
});
}
if (!sessionId) {
this._loginManager.getCurrentSessionProxy(currentSessionProxy => {
sessionId = currentSessionProxy.Id;
- log(`endSessionDialog: No XDG_SESSION_ID, fetched from logind: ${sessionId}`);
+ log('endSessionDialog: No XDG_SESSION_ID, fetched from logind: %d'.format(sessionId));
});
}
const Main = imports.ui.main;
const ModalDialog = imports.ui.modalDialog;
-var REPOSITORY_URL_BASE = 'https://extensions.gnome.org';
-var REPOSITORY_URL_DOWNLOAD = `${REPOSITORY_URL_BASE}/download-extension/%s.shell-extension.zip`;
-var REPOSITORY_URL_INFO = `${REPOSITORY_URL_BASE}/extension-info/`;
-var REPOSITORY_URL_UPDATE = `${REPOSITORY_URL_BASE}/update-info/`;
+var REPOSITORY_URL_DOWNLOAD = 'https://extensions.gnome.org/download-extension/%s.shell-extension.zip';
+var REPOSITORY_URL_INFO = 'https://extensions.gnome.org/extension-info/';
+var REPOSITORY_URL_UPDATE = 'https://extensions.gnome.org/update-info/';
let _httpSession;
_httpSession.queue_message(message, () => {
if (message.status_code != Soup.KnownStatusCode.OK) {
- Main.extensionManager.logExtensionError(uuid, `downloading info: ${message.status_code}`);
+ Main.extensionManager.logExtensionError(uuid, 'downloading info: %d'.format(message.status_code));
invocation.return_dbus_error('org.gnome.Shell.DownloadInfoError', message.status_code.toString());
return;
}
try {
info = JSON.parse(message.response_body.data);
} catch (e) {
- Main.extensionManager.logExtensionError(uuid, `parsing info: ${e}`);
+ Main.extensionManager.logExtensionError(uuid, 'parsing info: %s'.format(e.toString()));
invocation.return_dbus_error('org.gnome.Shell.ParseInfoError', e.toString());
return;
}
gotExtensionZipFile(session, message, uuid, dir, () => {
Main.extensionManager.notifyExtensionUpdate(uuid);
}, (code, msg) => {
- log(`Error while downloading update for extension ${uuid}: ${code} (${msg})`);
+ log('Error while downloading update for extension %s: %s (%s)'.format(uuid, code, msg));
});
});
}
let params = {
shell_version: Config.PACKAGE_VERSION,
installed: JSON.stringify(metadatas),
- disable_version_validation: `${versionCheck}`,
+ disable_version_validation: versionCheck.toString(),
};
let url = REPOSITORY_URL_UPDATE;
let dir = Gio.File.new_for_path(GLib.build_filenamev([global.userdatadir, 'extensions', uuid]));
let invocation = this._invocation;
function errback(code, msg) {
- log(`Error while installing ${uuid}: ${code} (${msg})`);
- invocation.return_dbus_error(`org.gnome.Shell.${code}`, msg || '');
+ log('Error while installing %s: %s (%s)'.format(uuid, code, msg));
+ invocation.return_dbus_error('org.gnome.Shell.%s'.format(code), msg || '');
}
function callback() {
let extension = Main.extensionManager.createExtensionObject(uuid, dir, ExtensionUtils.ExtensionType.PER_USER);
Main.extensionManager.loadExtension(extension);
if (!Main.extensionManager.enableExtension(uuid))
- throw new Error(`Cannot add ${uuid} to enabled extensions gsettings key`);
+ throw new Error('Cannot add %s to enabled extensions gsettings key'.format(uuid));
} catch (e) {
uninstallExtension(uuid);
errback('LoadExtensionError', e);
try {
disableFile.create(Gio.FileCreateFlags.REPLACE_DESTINATION, null);
} catch (e) {
- log(`Failed to create file ${disableFilename}: ${e.message}`);
+ log('Failed to create file %s: %s'.format(disableFilename, e.message));
}
GLib.timeout_add_seconds(GLib.PRIORITY_DEFAULT, 60, () => {
if (extension.state != ExtensionState.DISABLED)
return;
- let stylesheetNames = [`${global.session_mode}.css`, 'stylesheet.css'];
+ let stylesheetNames = ['%s.css'.format(global.session_mode), 'stylesheet.css'];
let theme = St.ThemeContext.get_for_stage(global.stage).get_theme();
for (let i = 0; i < stylesheetNames.length; i++) {
try {
if (!extension)
return;
- let message = `${error}`;
+ let message = error.toString();
extension.error = message;
extension.state = ExtensionState.ERROR;
extension.errors = [];
extension.errors.push(message);
- logError(error, `Extension ${uuid}`);
+ logError(error, 'Extension %s'.format(uuid));
this.emit('extension-state-changed', extension);
}
if (metadataContents instanceof Uint8Array)
metadataContents = imports.byteArray.toString(metadataContents);
} catch (e) {
- throw new Error(`Failed to load metadata.json: ${e}`);
+ throw new Error('Failed to load metadata.json: %s'.format(e.toString()));
}
let meta;
try {
meta = JSON.parse(metadataContents);
} catch (e) {
- throw new Error(`Failed to parse metadata.json: ${e}`);
+ throw new Error('Failed to parse metadata.json: %s'.format(e.toString()));
}
let requiredProperties = ['uuid', 'name', 'description', 'shell-version'];
for (let i = 0; i < requiredProperties.length; i++) {
let prop = requiredProperties[i];
if (!meta[prop])
- throw new Error(`missing "${prop}" property in metadata.json`);
+ throw new Error('missing "%s" property in metadata.json'.format(prop));
}
if (uuid != meta.uuid)
- throw new Error(`uuid "${meta.uuid}" from metadata.json does not match directory name "${uuid}"`);
+ throw new Error('uuid "%s" from metadata.json does not match directory name "%s"'.format(meta.uuid, uuid));
let extension = {
metadata: meta,
}
_loadExtensions() {
- global.settings.connect(`changed::${ENABLED_EXTENSIONS_KEY}`,
+ global.settings.connect('changed::%s'.format(ENABLED_EXTENSIONS_KEY),
this._onEnabledExtensionsChanged.bind(this));
- global.settings.connect(`changed::${DISABLED_EXTENSIONS_KEY}`,
+ global.settings.connect('changed::%s'.format(DISABLED_EXTENSIONS_KEY),
this._onEnabledExtensionsChanged.bind(this));
- global.settings.connect(`changed::${DISABLE_USER_EXTENSIONS_KEY}`,
+ global.settings.connect('changed::%s'.format(DISABLE_USER_EXTENSIONS_KEY),
this._onUserExtensionsEnabledChanged.bind(this));
- global.settings.connect(`changed::${EXTENSION_DISABLE_VERSION_CHECK_KEY}`,
+ global.settings.connect('changed::%s'.format(EXTENSION_DISABLE_VERSION_CHECK_KEY),
this._onVersionValidationChanged.bind(this));
- global.settings.connect(`writable-changed::${ENABLED_EXTENSIONS_KEY}`,
+ global.settings.connect('writable-changed::%s'.format(ENABLED_EXTENSIONS_KEY),
this._onSettingsWritableChanged.bind(this));
- global.settings.connect(`writable-changed::${DISABLED_EXTENSIONS_KEY}`,
+ global.settings.connect('writable-changed::%s'.format(DISABLED_EXTENSIONS_KEY),
this._onSettingsWritableChanged.bind(this));
this._enabledExtensions = this._getEnabledExtensions();
let uuid = info.get_name();
let existing = this.lookup(uuid);
if (existing) {
- log(`Extension ${uuid} already installed in ${existing.path}. ${dir.get_path()} will not be loaded`);
+ log('Extension %s already installed in %s. %s will not be loaded'.format(uuid, existing.path, dir.get_path()));
return;
}
try {
extension = this.createExtensionObject(uuid, dir, type);
} catch (e) {
- logError(e, `Could not load extension ${uuid}`);
+ logError(e, 'Could not load extension %s'.format(uuid));
return;
}
this.loadExtension(extension);
// special case this since the default is way, way too verbose
return '<js function>';
} else {
- return `${o}`;
+ return o.toString();
}
}
this.add(cmdTxt);
let box = new St.BoxLayout({});
this.add(box);
- let resultTxt = new St.Label({ text: `r(${index}) = ` });
+ let resultTxt = new St.Label({ text: 'r(%d) = '.format(index) });
resultTxt.clutter_text.ellipsize = Pango.EllipsizeMode.END;
box.add(resultTxt);
let objLink = new ObjLink(this._lookingGlass, o);
box.add_child(windowLink);
let propsBox = new St.BoxLayout({ vertical: true, style: 'padding-left: 6px;' });
box.add(propsBox);
- propsBox.add(new St.Label({ text: `wmclass: ${metaWindow.get_wm_class()}` }));
+ propsBox.add(new St.Label({ text: 'wmclass: %s'.format(metaWindow.get_wm_class()) }));
let app = tracker.get_window_app(metaWindow);
if (app != null && !app.is_window_backed()) {
let icon = app.create_icon_texture(22);
link = new St.Label({ text: '<error>' });
}
let box = new St.BoxLayout();
- box.add(new St.Label({ text: `${propName}: ` }));
+ box.add(new St.Label({ text: '%s: '.format(propName) }));
box.add(link);
this._container.add_actor(box);
}
this._target = target;
this._pointerTarget = target;
- let position = `[inspect x: ${stageX} y: ${stageY}]`;
+ let position = '[inspect x: %d y: %d]'.format(stageX, stageY);
this._displayText.text = '';
- this._displayText.text = `${position} ${this._target}`;
+ this._displayText.text = '%s %s'.format(position, this._target);
this._lookingGlass.setBorderPaintTarget(this._target);
}
inspectIcon.connect('button-press-event', () => {
let inspector = new Inspector(this);
inspector.connect('target', (i, target, stageX, stageY) => {
- this._pushResult(`inspect(${Math.round(stageX)}, ${Math.round(stageY)})`, target);
+ this._pushResult('inspect(%d, %d)'.format(Math.round(stageX), Math.round(stageY)), target);
});
inspector.connect('closed', () => {
this.show();
// monospace font to be bold/oblique/etc. Could easily be added here.
let size = fontDesc.get_size() / 1024.;
let unit = fontDesc.get_size_is_absolute() ? 'px' : 'pt';
- this.style = `
- font-size: ${size}${unit};
- font-family: "${fontDesc.get_family()}";`;
+ this.style = 'font-size: %d%s; font-family: "%s";'.format(
+ size, unit, fontDesc.get_family());
}
setBorderPaintTarget(obj) {
this._history.addItem(command);
let lines = command.split(';');
- lines.push(`return ${lines.pop()}`);
+ lines.push('return %s'.format(lines.pop()));
let fullCmd = commandHeader + lines.join(';');
try {
resultObj = Function(fullCmd)();
} catch (e) {
- resultObj = `<exception ${e}>`;
+ resultObj = '<exception %s>'.format(e.toString());
}
this._pushResult(command, resultObj);
try {
return this._resultsArea.get_child_at_index(idx - this._offset).o;
} catch (e) {
- throw new Error(`Unknown result at index ${idx}`);
+ throw new Error('Unknown result at index %d'.format(idx));
}
}
if (sessionMode.currentMode != 'gdm' &&
sessionMode.currentMode != 'initial-setup') {
GLib.log_structured(LOG_DOMAIN, GLib.LogLevelFlags.LEVEL_MESSAGE, {
- 'MESSAGE': `GNOME Shell started at ${_startDate}`,
+ 'MESSAGE': 'GNOME Shell started at %s'.format(_startDate),
'MESSAGE_ID': GNOMESHELL_STARTED_MESSAGE_ID,
});
}
let perfModuleName = GLib.getenv("SHELL_PERF_MODULE");
if (perfModuleName) {
let perfOutput = GLib.getenv("SHELL_PERF_OUTPUT");
- let module = eval(`imports.perf.${perfModuleName};`);
+ let module = eval('imports.perf.%s;'.format(perfModuleName));
Scripting.runPerfScript(module, perfOutput);
}
});
function _getStylesheet(name) {
let stylesheet;
- stylesheet = Gio.File.new_for_uri(`resource:///org/gnome/shell/theme/${name}`);
+ stylesheet = Gio.File.new_for_uri('resource:///org/gnome/shell/theme/%s'.format(name));
if (stylesheet.query_exists(null))
return stylesheet;
return stylesheet;
}
- stylesheet = Gio.File.new_for_path(`${global.datadir}/theme/${name}`);
+ stylesheet = Gio.File.new_for_path('%s/theme/%s'.format(global.datadir, name));
if (stylesheet.query_exists(null))
return stylesheet;
if (_themeResource)
_themeResource._unregister();
- _themeResource = Gio.Resource.load(`${global.datadir}/gnome-shell-theme.gresource`);
+ _themeResource = Gio.Resource.load('%s/gnome-shell-theme.gresource'.format(global.datadir));
_themeResource._register();
}
function _loadOskLayouts() {
- _oskResource = Gio.Resource.load(`${global.datadir}/gnome-shell-osk-layouts.gresource`);
+ _oskResource = Gio.Resource.load('%s/gnome-shell-osk-layouts.gresource'.format(global.datadir));
_oskResource._register();
}
function notifyError(msg, details) {
// Also print to stderr so it's logged somewhere
if (details)
- log(`error: ${msg}: ${details}`);
+ log('error: %s: %s'.format(msg, details));
else
- log(`error: ${msg}`);
+ log('error: %s'.format(msg));
notify(msg, details);
}
*/
function initializeDeferredWork(actor, callback) {
// Turn into a string so we can use as an object property
- let workId = `${++_deferredWorkSequence}`;
+ let workId = (++_deferredWorkSequence).toString();
_deferredWorkData[workId] = { actor,
callback };
actor.connect('notify::mapped', () => {
if (urlId != -1) {
let url = this._urls[urlId].url;
if (!url.includes(':'))
- url = `http://${url}`;
+ url = 'http://%s'.format(url);
Gio.app_info_launch_default_for_uri(
url, global.create_app_launch_context(0, -1));
for (let i = 0; i < urls.length; i++) {
let url = urls[i];
let str = this._text.substr(pos, url.pos - pos);
- markup += `${str}<span foreground="${this._linkColor}"><u>${url.url}</u></span>`;
+ markup += '%s<span foreground="%s"><u>%s</u></span>'.format(str, this._linkColor, url.url);
pos = url.pos + url.url.length;
}
markup += this._text.substr(pos);
this._canonicalId = this._canonicalizeId(id);
this._masterSettings = new Gio.Settings({ schema_id: 'org.gnome.desktop.notifications' });
- this._settings = new Gio.Settings({ schema_id: 'org.gnome.desktop.notifications.application',
- path: `/org/gnome/desktop/notifications/application/${this._canonicalId}/` });
+ this._settings = new Gio.Settings({
+ schema_id: 'org.gnome.desktop.notifications.application',
+ path: '/org/gnome/desktop/notifications/application/%s/'.format(this._canonicalId),
+ });
this._masterSettings.connect('changed', this._changed.bind(this));
this._settings.connect('changed', this._changed.bind(this));
}
store() {
- this._settings.set_string('application-id', `${this.id}.desktop`);
+ this._settings.set_string('application-id', '%s.desktop'.format(this.id));
let apps = this._masterSettings.get_strv('application-children');
if (!apps.includes(this._canonicalId)) {
add(source) {
if (this.contains(source)) {
- log(`Trying to re-add source ${source.title}`);
+ log('Trying to re-add source %s'.format(source.title));
return;
}
// so prefer activating the app via .desktop file if possible
let app = null;
if (this._mprisProxy.DesktopEntry) {
- let desktopId = `${this._mprisProxy.DesktopEntry}.desktop`;
+ let desktopId = '%s.desktop'.format(this._mprisProxy.DesktopEntry);
app = Shell.AppSystem.get_default().lookup_app(desktopId);
}
if (!Array.isArray(this._trackArtists) ||
!this._trackArtists.every(artist => typeof artist === 'string')) {
if (typeof this._trackArtists !== 'undefined') {
- log(`Received faulty track artist metadata from ${
- this._busName}; expected an array of strings, got ${
- this._trackArtists} (${typeof this._trackArtists})`);
+ log(('Received faulty track artist metadata from %s; ' +
+ 'expected an array of strings, got %s (%s)').format(
+ this._busName, this._trackArtists, typeof this._trackArtists));
}
this._trackArtists = [_("Unknown artist")];
}
this._trackTitle = metadata['xesam:title'];
if (typeof this._trackTitle !== 'string') {
if (typeof this._trackTitle !== 'undefined') {
- log(`Received faulty track title metadata from ${
- this._busName}; expected a string, got ${
- this._trackTitle} (${typeof this._trackTitle})`);
+ log(('Received faulty track title metadata from %s; ' +
+ 'expected a string, got %s (%s)').format(
+ this._busName, this._trackTitle, typeof this._trackTitle));
}
this._trackTitle = _("Unknown title");
}
this._trackCoverUrl = metadata['mpris:artUrl'];
if (typeof this._trackCoverUrl !== 'string') {
if (typeof this._trackCoverUrl !== 'undefined') {
- log(`Received faulty track cover art metadata from ${
- this._busName}; expected a string, got ${
- this._trackCoverUrl} (${typeof this._trackCoverUrl})`);
+ log(('Received faulty track cover art metadata from %s; ' +
+ 'expected a string, got %s (%s)').format(
+ this._busName, this._trackCoverUrl, typeof this._trackCoverUrl));
}
this._trackCoverUrl = '';
}
return app;
if (appId) {
- app = Shell.AppSystem.get_default().lookup_app(`${appId}.desktop`);
+ app = Shell.AppSystem.get_default().lookup_app('%s.desktop'.format(appId));
if (app != null)
return app;
}
}
function getPlatformData() {
- let startupId = GLib.Variant.new('s', `_TIME${global.get_current_time()}`);
+ let startupId = GLib.Variant.new('s', '_TIME%s'.format(global.get_current_time()));
return { "desktop-startup-id": startupId };
}
if (!GLib.Variant.is_object_path(objectPath))
throw new InvalidAppError();
- let app = Shell.AppSystem.get_default().lookup_app(`${appId}.desktop`);
+ let app = Shell.AppSystem.get_default().lookup_app('%s.desktop'.format(appId));
if (!app)
throw new InvalidAppError();
}
_getSlide() {
- throw new GObject.NotImplementedError(`_getSlide in ${this.constructor.name}`);
+ throw new GObject.NotImplementedError('_getSlide in %s'.format(this.constructor.name));
}
_updateSlide() {
return '<?xml version="1.0" encoding="UTF-8" standalone="no"?>' +
'<svg version="1.1" xmlns="http://www.w3.org/2000/svg" ' +
'xmlns:xi="http://www.w3.org/2001/XInclude" ' +
- `width="${ // " (give xgettext the paired quotes it expects)
- this._imageWidth
- }" height="${this._imageHeight}"> ` + // "
+ 'width="%d" height="%d">'.format(this._imageWidth, this._imageHeight) +
'<style type="text/css">';
}
for (let i = 0; i < this._activeButtons.length; i++) {
let ch = String.fromCharCode('A'.charCodeAt() + this._activeButtons[i]);
- css += `.${ch} {
- stroke: ${ACTIVE_COLOR} !important;
- fill: ${ACTIVE_COLOR} !important;
- }`;
+ css += '.%s {'.format(ch);
+ css += ' stroke: %s !important;'.format(ACTIVE_COLOR);
+ css += ' fill: %s !important;'.format(ACTIVE_COLOR);
+ css += '}';
}
return css;
let leaderPos, leaderSize, pos;
let found, direction;
- [found, pos] = this._handle.get_position_sub(`#${labelName}`);
+ [found, pos] = this._handle.get_position_sub('#%s'.format(labelName));
if (!found)
return [false];
- [found, leaderPos] = this._handle.get_position_sub(`#${leaderName}`);
- [found, leaderSize] = this._handle.get_dimensions_sub(`#${leaderName}`);
+ [found, leaderPos] = this._handle.get_position_sub('#%s'.format(leaderName));
+ [found, leaderSize] = this._handle.get_dimensions_sub('#%s'.format(leaderName));
if (!found)
return [false];
getButtonLabelCoords(button) {
let ch = String.fromCharCode('A'.charCodeAt() + button);
- let labelName = `Label${ch}`;
- let leaderName = `Leader${ch}`;
+ let labelName = 'Label%s'.format(ch);
+ let leaderName = 'Leader%s'.format(ch);
return this._getItemLabelCoords(labelName, leaderName);
}
getRingLabelCoords(number, dir) {
let numStr = number > 0 ? (number + 1).toString() : '';
let dirStr = dir == CW ? 'CW' : 'CCW';
- let labelName = `LabelRing${numStr}${dirStr}`;
- let leaderName = `LeaderRing${numStr}${dirStr}`;
+ let labelName = 'LabelRing%s%s'.format(numStr, dirStr);
+ let leaderName = 'LeaderRing%s%s'.format(numStr, dirStr);
return this._getItemLabelCoords(labelName, leaderName);
}
getStripLabelCoords(number, dir) {
let numStr = number > 0 ? (number + 1).toString() : '';
let dirStr = dir == UP ? 'Up' : 'Down';
- let labelName = `LabelStrip${numStr}${dirStr}`;
- let leaderName = `LeaderStrip${numStr}${dirStr}`;
+ let labelName = 'LabelStrip%s%s'.format(numStr, dirStr);
+ let leaderName = 'LeaderStrip%s%s'.format(numStr, dirStr);
return this._getItemLabelCoords(labelName, leaderName);
}
}
this._titleLabel.clutter_text.set_markup(
- `<span size="larger"><b>${title}</b></span>`);
+ '<span size="larger"><b>%s</b></span>'.format(title));
}
_isEditedAction(type, number, dir) {
_startButtonActionEdition(button) {
let ch = String.fromCharCode('A'.charCodeAt() + button);
- let key = `button${ch}`;
+ let key = 'button%s'.format(ch);
this._startActionEdition(key, Meta.PadActionType.BUTTON, button);
}
addToStatusArea(role, indicator, position, box) {
if (this.statusArea[role])
- throw new Error(`Extension point conflict: there is already a status indicator for role ${role}`);
+ throw new Error('Extension point conflict: there is already a status indicator for role %s'.format(role));
if (!(indicator instanceof PanelMenu.Button))
throw new TypeError('Status indicator must be an instance of PanelMenu.Button');
var PopupMenuBase = class {
constructor(sourceActor, styleClass) {
if (this.constructor === PopupMenuBase)
- throw new TypeError(`Cannot instantiate abstract class ${this.constructor.name}`);
+ throw new TypeError('Cannot instantiate abstract class %s'.format(this.constructor.name));
this.sourceActor = sourceActor;
this.focusActor = sourceActor;
let app = Shell.AppSystem.get_default().lookup_app(desktopFile);
if (!app) {
- log(`Settings panel for desktop file ${desktopFile} could not be loaded!`);
+ log('Settings panel for desktop file %s could not be loaded!'.format(desktopFile));
return;
}
if (inTerminal) {
let exec = this._terminalSettings.get_string(EXEC_KEY);
let execArg = this._terminalSettings.get_string(EXEC_ARG_KEY);
- command = `${exec} ${execArg} ${input}`;
+ command = '%s %s %s'.format(exec, execArg, input);
}
Util.trySpawnCommandLine(command);
} catch (e) {
} else {
if (input.charAt(0) == '~')
input = input.slice(1);
- path = `${GLib.get_home_dir()}/${input}`;
+ path = '%s/%s'.format(GLib.get_home_dir(), input);
}
if (GLib.file_test(path, GLib.FileTest.EXISTS)) {
});
this._settings = new Gio.Settings({ schema_id: SCREENSAVER_SCHEMA });
- this._settings.connect(`changed::${LOCK_ENABLED_KEY}`, this._syncInhibitor.bind(this));
+ this._settings.connect('changed::%s'.format(LOCK_ENABLED_KEY), this._syncInhibitor.bind(this));
this._lockSettings = new Gio.Settings({ schema_id: LOCKDOWN_SCHEMA });
- this._lockSettings.connect(`changed::${DISABLE_LOCK_KEY}`, this._syncInhibitor.bind(this));
+ this._lockSettings.connect('changed::%s'.format(DISABLE_LOCK_KEY), this._syncInhibitor.bind(this));
this._isModal = false;
this._isGreeter = false;
this.provider.getResultMetas(metasNeeded, metas => {
if (this._cancellable.is_cancelled()) {
if (metas.length > 0)
- log(`Search provider ${this.provider.id} returned results after the request was canceled`);
+ log('Search provider %s returned results after the request was canceled'.format(this.provider.id));
callback(false);
return;
}
if (metas.length != metasNeeded.length) {
- log(`Wrong number of result metas returned by search provider ${this.provider.id}: ` +
- `expected ${metasNeeded.length} but got ${metas.length}`);
+ log('Wrong number of result metas returned by search provider %s: '.format(this.provider.id) +
+ 'expected %d but got %d'.format(metasNeeded.length, metas.length));
callback(false);
return;
}
if (metas.some(meta => !meta.name || !meta.id)) {
- log(`Invalid result meta returned from search provider ${this.provider.id}`);
+ log('Invalid result meta returned from search provider %s'.format(this.provider.id));
callback(false);
return;
}
this._searchTimeoutId = GLib.timeout_add(GLib.PRIORITY_DEFAULT, 150, this._onSearchTimeout.bind(this));
let escapedTerms = this._terms.map(term => Shell.util_regex_escape(term));
- this._highlightRegex = new RegExp(`(${escapedTerms.join('|')})`, 'gi');
+ this._highlightRegex = new RegExp('(%s)'.format(escapedTerms.join('|')), 'gi');
this.emit('terms-changed');
}
_setCurrentRequest(invocation, id, type) {
let oldId = this._currentId;
let oldType = this._currentType;
- let requestId = `${id}@${invocation.get_sender()}`;
+ let requestId = '%s@%s'.format(id, invocation.get_sender());
this._clearCurrentRequest(Gio.MountOperationResult.UNHANDLED, {});
this.add_child(this._hbox);
this._a11ySettings = new Gio.Settings({ schema_id: A11Y_SCHEMA });
- this._a11ySettings.connect(`changed::${KEY_ALWAYS_SHOW}`, this._queueSyncMenuVisibility.bind(this));
+ this._a11ySettings.connect('changed::%s'.format(KEY_ALWAYS_SHOW), this._queueSyncMenuVisibility.bind(this));
let highContrast = this._buildHCItem();
this.menu.addMenuItem(highContrast);
settings.is_writable(key),
enabled => settings.set_boolean(key, enabled));
- settings.connect(`changed::${key}`, () => {
+ settings.connect('changed::%s'.format(key), () => {
widget.setToggleState(settings.get_boolean(key));
this._queueSyncMenuVisibility();
}
});
- interfaceSettings.connect(`changed::${KEY_GTK_THEME}`, () => {
+ interfaceSettings.connect('changed::%s'.format(KEY_GTK_THEME), () => {
let value = interfaceSettings.get_string(KEY_GTK_THEME);
if (value == HIGH_CONTRAST_THEME) {
highContrast.setToggleState(true);
this._queueSyncMenuVisibility();
});
- interfaceSettings.connect(`changed::${KEY_ICON_THEME}`, () => {
+ interfaceSettings.connect('changed::%s'.format(KEY_ICON_THEME), () => {
let value = interfaceSettings.get_string(KEY_ICON_THEME);
if (value != HIGH_CONTRAST_THEME)
iconTheme = value;
}
});
- settings.connect(`changed::${KEY_TEXT_SCALING_FACTOR}`, () => {
+ settings.connect('changed::%s'.format(KEY_TEXT_SCALING_FACTOR), () => {
factor = settings.get_double(KEY_TEXT_SCALING_FACTOR);
let active = factor > 1.0;
widget.setToggleState(active);
this.add_child(this._hbox);
this._a11ySettings = new Gio.Settings({ schema_id: MOUSE_A11Y_SCHEMA });
- this._a11ySettings.connect(`changed::${KEY_DWELL_CLICK_ENABLED}`, this._syncMenuVisibility.bind(this));
- this._a11ySettings.connect(`changed::${KEY_DWELL_MODE}`, this._syncMenuVisibility.bind(this));
+ this._a11ySettings.connect('changed::%s'.format(KEY_DWELL_CLICK_ENABLED), this._syncMenuVisibility.bind(this));
+ this._a11ySettings.connect('changed::%s'.format(KEY_DWELL_MODE), this._syncMenuVisibility.bind(this));
this._seat = Clutter.get_default_backend().get_default_seat();
this._seat.connect('ptr-a11y-dwell-click-type-changed', this._updateClickType.bind(this));
return this.id;
if (engineDesc.variant && engineDesc.variant.length > 0)
- return `${engineDesc.layout}+${engineDesc.variant}`;
+ return '%s+%s'.format(engineDesc.layout, engineDesc.variant);
else
return engineDesc.layout;
}
var InputSourceSettings = class {
constructor() {
if (this.constructor === InputSourceSettings)
- throw new TypeError(`Cannot instantiate abstract class ${this.constructor.name}`);
+ throw new TypeError('Cannot instantiate abstract class %s'.format(this.constructor.name));
}
_emitInputSourcesChanged() {
try {
props = conn.call_finish(result).deep_unpack()[0];
} catch (e) {
- log(`Could not get properties from ${this._BUS_NAME}`);
+ log('Could not get properties from %s'.format(this._BUS_NAME));
return;
}
let layouts = props['X11Layout'].unpack();
for (let i = 0; i < layouts.length && !!layouts[i]; i++) {
let id = layouts[i];
if (variants[i])
- id += `+${variants[i]}`;
+ id += '+%s'.format(variants[i]);
sourcesList.push({ type: INPUT_SOURCE_TYPE_XKB, id });
}
return sourcesList;
this._KEY_PER_WINDOW = 'per-window';
this._settings = new Gio.Settings({ schema_id: this._DESKTOP_INPUT_SOURCES_SCHEMA });
- this._settings.connect(`changed::${this._KEY_INPUT_SOURCES}`, this._emitInputSourcesChanged.bind(this));
- this._settings.connect(`changed::${this._KEY_KEYBOARD_OPTIONS}`, this._emitKeyboardOptionsChanged.bind(this));
- this._settings.connect(`changed::${this._KEY_PER_WINDOW}`, this._emitPerWindowChanged.bind(this));
+ this._settings.connect('changed::%s'.format(this._KEY_INPUT_SOURCES), this._emitInputSourcesChanged.bind(this));
+ this._settings.connect('changed::%s'.format(this._KEY_KEYBOARD_OPTIONS), this._emitKeyboardOptionsChanged.bind(this));
+ this._settings.connect('changed::%s'.format(this._KEY_PER_WINDOW), this._emitPerWindowChanged.bind(this));
}
_getSourcesList(key) {
let description = xkbLayout;
if (xkbVariant.length > 0)
- description = `${description}\t${xkbVariant}`;
+ description = '%s\t%s'.format(description, xkbVariant);
Util.spawn(['gkbd-keyboard-display', '-l', description]);
}
super._init();
this._settings = new Gio.Settings({ schema_id: LOCATION_SCHEMA });
- this._settings.connect(`changed::${ENABLED}`,
+ this._settings.connect('changed::%s'.format(ENABLED),
this._onMaxAccuracyLevelChanged.bind(this));
- this._settings.connect(`changed::${MAX_ACCURACY_LEVEL}`,
+ this._settings.connect('changed::%s'.format(MAX_ACCURACY_LEVEL),
this._onMaxAccuracyLevelChanged.bind(this));
this._indicator = this._addIndicator();
this._onAuthDone = onAuthDone;
let appSystem = Shell.AppSystem.get_default();
- this._app = appSystem.lookup_app(`${this.desktopId}.desktop`);
+ this._app = appSystem.lookup_app('%s.desktop'.format(this.desktopId));
if (this._app == null || this._permStoreProxy == null) {
this._completeAuth();
var NMConnectionSection = class NMConnectionSection {
constructor(client) {
if (this.constructor === NMConnectionSection)
- throw new TypeError(`Cannot instantiate abstract type ${this.constructor.name}`);
+ throw new TypeError('Cannot instantiate abstract type %s'.format(this.constructor.name));
this._client = client;
super(client);
if (this.constructor === NMConnectionDevice)
- throw new TypeError(`Cannot instantiate abstract type ${this.constructor.name}`);
+ throw new TypeError('Cannot instantiate abstract type %s'.format(this.constructor.name));
this._device = device;
this._description = '';
}
_getSignalIcon() {
- return `network-cellular-signal-${signalToIcon(this._mobileDevice.signal_quality)}-symbolic`;
+ return 'network-cellular-signal-%s-symbolic'.format(
+ signalToIcon(this._mobileDevice.signal_quality));
}
};
}
_getSignalIcon() {
- if (this._ap.mode == NM80211Mode.ADHOC)
+ if (this._ap.mode == NM80211Mode.ADHOC) {
return 'network-workgroup-symbolic';
- else
- return `network-wireless-signal-${signalToIcon(this._ap.strength)}-symbolic`;
+ } else {
+ return 'network-wireless-signal-%s-symbolic'.format(
+ signalToIcon(this._ap.strength));
+ }
}
});
}
if (this._canReachInternet())
- return `network-wireless-signal-${signalToIcon(ap.strength)}-symbolic`;
+ return 'network-wireless-signal-%s-symbolic'.format(signalToIcon(ap.strength));
else
return 'network-wireless-no-route-symbolic';
}
try {
this._deviceAdded(this._client, devices[i], true);
} catch (e) {
- log(`Failed to add device ${devices[i]}: ${e}`);
+ log('Failed to add device %s: %s'.format(devices[i], e.toString()));
}
}
this._syncDeviceNames();
} catch (e) { }
});
} else {
- log(`Invalid result from portal helper: ${result}`);
+ log('Invalid result from portal helper: %s'.format(result));
}
}
new PortalHelperProxy(Gio.DBus.session, 'org.gnome.Shell.PortalHelper',
'/org/gnome/Shell/PortalHelper', (proxy, error) => {
if (error) {
- log(`Error launching the portal helper: ${error}`);
+ log('Error launching the portal helper: %s'.format(error));
return;
}
super._init();
this._desktopSettings = new Gio.Settings({ schema_id: 'org.gnome.desktop.interface' });
- this._desktopSettings.connect(`changed::${SHOW_BATTERY_PERCENTAGE}`,
+ this._desktopSettings.connect('changed::%s'.format(SHOW_BATTERY_PERCENTAGE),
this._sync.bind(this));
this._indicator = this._addIndicator();
fillLevel === 100)
icon = 'battery-level-100-charged-symbolic';
else
- icon = `battery-level-${fillLevel}${chargingState}-symbolic`;
+ icon = 'battery-level-%d%s-symbolic'.format(fillLevel, chargingState);
// Make sure we fall back to fallback-icon-name and not GThemedIcon's
// default fallbacks
let auth = unlocked && allowed;
policy[0] = auth;
- log(`thunderbolt: [${device.Name}] auto enrollment: ${auth ? 'yes' : 'no'} (allowed: ${allowed ? 'yes' : 'no'})`);
+ log('thunderbolt: [%s] auto enrollment: %s (allowed: %s)'.format(
+ device.Name, auth ? 'yes' : 'no', allowed ? 'yes' : 'no'));
if (auth)
return; /* we are done */
this._slider = new Slider.Slider(0);
this._soundSettings = new Gio.Settings({ schema_id: 'org.gnome.desktop.sound' });
- this._soundSettings.connect(`changed::${ALLOW_AMPLIFIED_VOLUME_KEY}`, this._amplifySettingsChanged.bind(this));
+ this._soundSettings.connect('changed::%s'.format(ALLOW_AMPLIFIED_VOLUME_KEY), this._amplifySettingsChanged.bind(this));
this._amplifySettingsChanged();
this._sliderChangedId = this._slider.connect('notify::value',
let count = source.unseenCount;
let countLabel = new St.Label({
- text: `${count}`,
+ text: count.toString(),
visible: count > 1,
style_class: 'unlock-dialog-notification-count-text',
});
}
let label = new St.Label({ style_class: 'unlock-dialog-notification-count-text' });
- label.clutter_text.set_markup(`<b>${n.title}</b> ${body}`);
+ label.clutter_text.set_markup('<b>%s</b> %s'.format(n.title, body));
textBox.add(label);
visible = true;
this._showSource(source, obj, obj.sourceBox);
} else {
let count = source.unseenCount;
- obj.countLabel.text = `${count}`;
+ obj.countLabel.text = count.toString();
obj.countLabel.visible = count > 1;
}
}
_syncEnabled() {
- let animating = this.actor.get_transition(`@effects.${this.name}.brightness`) != null;
+ let transitionName = '@effects.%s.brightness'.format(this.name);
+ let animating = this.actor.get_transition(transitionName) != null;
let dimmed = this.brightness.red != 127;
this.enabled = this._enabled && (animating || dimmed);
}
let val = 127 * (1 + (dimmed ? 1 : 0) * DIM_BRIGHTNESS);
let color = Clutter.Color.new(val, val, val, 255);
- this.actor.ease_property(`@effects.${this.name}.brightness`, color, {
+ let transitionName = '@effects.%s.brightness'.format(this.name);
+ this.actor.ease_property(transitionName, color, {
mode: Clutter.AnimationMode.LINEAR,
duration: (dimmed ? DIM_TIME : UNDIM_TIME) * (animate ? 1 : 0),
onComplete: () => this._syncEnabled(),
projects / gnome-shell.git / commitdiff